home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / GDIMETA.PAK / PALETTE.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  8KB  |  300 lines
  1. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright (C) 1993 - 1995  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  MODULE:   palette.c
  9. //
  10. //  PURPOSE:  Contains palette routines
  11. //
  12. //  FUNCTIONS:
  13. //    ProcessPaletteChanged  - Process the WM_PALETTECHANGED message
  14. //    ProcessQueryNewPalette - Process the WM_QUERYNEWPALETTE message
  15. //    IsPaletteDevice        - Checks display for Windows palette
  16. //                             capabilities.
  17. //    PalEntriesOnDevice     - Get the number of palette entries on
  18. //                             the specified device
  19. //    GetSystemPalette       - Gets the current system palette
  20. //    ColorsInPalette        - Given a handle to a palette, returns the
  21. //                             # of colors in that palette.
  22. //
  23. //  COMMENTS:
  24. //
  25.  
  26.  
  27. #include <windows.h>            // required for all Windows applications
  28. #include <windowsx.h>
  29. #include <commctrl.h>
  30. #include "globals.h"            // prototypes specific to this application
  31. #include "palette.h" 
  32.  
  33.  
  34. //
  35. //  FUNCTION: ProcessPaletteChanged(HWND, WPARAM)
  36. //
  37. //  PURPOSE:  Process the WM_PALETTECHANGED message
  38. //
  39. //  PARAMETERS:
  40. //    hwnd     -  Handle of window receiving the message.
  41. //    wparam    - Handle of window that changed the palette.
  42. //
  43. //  RETURN VALUE:
  44. //    TRUE if message processed, else FALSE.
  45. //
  46. //  COMMENTS:
  47. //    The WM_PALETTECHANGED message informs all windows that the window with
  48. //    input focus has realized its logical palette, thereby changing the
  49. //    system palette. This message allows a window without input focus that
  50. //    uses a color palette to realize its logical palettes and update its
  51. //    client area.
  52. //
  53. //    This message is sent to all windows, including the one that changed
  54. //    the system palette and caused this message to be sent. The wParam of
  55. //    this message contains the handle of the window that caused the system
  56. //    palette to change. To avoid an infinite loop, care must be taken to
  57. //    check that the wParam of this message does not match the window's handle.
  58. //            
  59. LRESULT ProcessPaletteChanged(HWND hwnd, WPARAM wparam)
  60. {
  61.     HDC      hDC;      // Handle to device context
  62.     HPALETTE hOldPal;  // Handle to previous logical palette
  63.  
  64.     // Before processing this message, make sure we are indeed using a palette
  65.     if (hPalette)
  66.     {
  67.         // If this application did not change the palette, select
  68.         // and realize this application's palette
  69.         if ((HWND)wparam != hwnd)
  70.         {
  71.             // get a display context for the window
  72.             hDC = GetDC(hwnd);
  73.  
  74.             // Select and realize our palette
  75.             hOldPal = SelectPalette(hDC, hPalette, TRUE);
  76.             RealizePalette(hDC);
  77.  
  78.             // When updating the colors for an inactive window,
  79.             // UpdateColors can be called because it is faster than
  80.             // redrawing the client area (even though the results are
  81.             // not as good)
  82.             UpdateColors(hDC);
  83.  
  84.             // Clean up
  85.             if (hOldPal)
  86.                 SelectPalette(hDC, hOldPal, FALSE);   
  87.                 
  88.             ReleaseDC(hwnd, hDC);
  89.         } 
  90.             
  91.         // message processed
  92.         return TRUE;  
  93.     }
  94.          
  95.     // message not processed
  96.     return FALSE;  
  97. }
  98.  
  99.  
  100. //
  101. //  FUNCTION: ProcessQueryNewPalette(HWND)
  102. //
  103. //  PURPOSE:  Process the WM_QUERYNEWPALETTE message.
  104. //
  105. //  PARAMETERS:
  106. //    hwnd     -  Handle of window receiving the message. 
  107. //
  108. //  RETURN VALUE:
  109. //    TRUE if message processed, else FALSE.
  110. //
  111. //  COMMENTS:
  112. //    The WM_QUERYNEWPALETTE message informs a window that it is about to
  113. //    receive input focus. In response, the window receiving focus should
  114. //    realize its palette as a foreground palette and update its client
  115. //    area. If the window realizes its palette, it should return TRUE;
  116. //    otherwise, it should return FALSE.
  117. //
  118. LRESULT ProcessQueryNewPalette(HWND hwnd)
  119. {
  120.     HDC      hDC;      // Handle to device context
  121.     HPALETTE hOldPal;  // Handle to previous logical palette
  122.  
  123.     // Only process the message if a palette is in use
  124.     if (hPalette)
  125.     {
  126.         // get a display context for the window       
  127.         hDC = GetDC(hwnd);
  128.  
  129.         // Select and realize our palette
  130.         hOldPal = SelectPalette(hDC, hPalette, FALSE);
  131.         RealizePalette(hDC);
  132.  
  133.         // Redraw the entire client area
  134.         InvalidateRect(hwnd, NULL, TRUE);
  135.         UpdateWindow(hwnd);
  136.  
  137.         // Clean up
  138.         if (hOldPal)
  139.             SelectPalette(hDC, hOldPal, FALSE);
  140.         ReleaseDC(hwnd, hDC);
  141.  
  142.         // Message processed
  143.         return TRUE;
  144.     }
  145.     
  146.     // Message not processed
  147.     return FALSE;
  148. }
  149.  
  150. //
  151. //  FUNCTION: IsPaletteDevice()
  152. //
  153. //  PURPOSE:  Checks display for Windows palette capabilities.
  154. //
  155. //  PARAMETERS:
  156. //    None.
  157. //
  158. //  RETURN VALUE:
  159. //    TRUE if a palette device, FALSE otherwise
  160. //
  161. //  COMMENTS:
  162. //
  163. BOOL IsPaletteDevice()
  164. {
  165.     HDC hdc;
  166.     int iRastercaps;
  167.     
  168.     hdc = GetDC(NULL);
  169.     iRastercaps = GetDeviceCaps(hdc, RASTERCAPS);
  170.     ReleaseDC(NULL, hdc);
  171.     
  172.     return ((iRastercaps & RC_PALETTE) ? TRUE : FALSE);
  173. }
  174.  
  175.  
  176. //
  177. //  FUNCTION: PalEntriesOnDevice(HDC)
  178. //
  179. //  PURPOSE:  Get the number of palette entries on the specified device
  180. //
  181. //  PARAMETERS:
  182. //    hDC          - device context
  183. //
  184. //  RETURN VALUE:
  185. //    The number of palette entries on device
  186. //
  187. //  COMMENTS:
  188. //
  189. //
  190. int PalEntriesOnDevice(HDC hDC)
  191. {
  192.     int nColors;  // number of colors
  193.  
  194.     // Find out the number of palette entries on this device.
  195.     
  196.     nColors = GetDeviceCaps(hDC, SIZEPALETTE);
  197.  
  198.     // For non-palette devices, we'll use the # of system
  199.     // colors for our palette size.
  200.  
  201.     if (!nColors)
  202.         nColors = GetDeviceCaps(hDC, NUMCOLORS);
  203.  
  204.     return nColors;
  205. }
  206.  
  207.  
  208. //
  209. //  FUNCTION: GetSystemPalette(void)
  210. //
  211. //  PURPOSE:  This routine returns a handle to a palette which represents
  212. //            the system palette (each entry is an offset into the system
  213. //            palette instead of an RGB with a flag of PC_EXPLICIT).
  214. //            Useful for dumping the system palette.
  215. //
  216. //  PARAMETERS:
  217. //    None.
  218. //
  219. //  RETURN VALUE:
  220. //    Handle to a palette consisting of the system palette.
  221. //
  222. //  COMMENTS:
  223. //
  224.  
  225. HPALETTE GetSystemPalette(void)
  226. {
  227.     HDC          hDC;
  228.     HPALETTE     hPal;
  229.     HANDLE       hLogPal;
  230.     LPLOGPALETTE lpLogPal;
  231.      int          i, nColors;
  232.  
  233.      // Find out how many palette entries we want.
  234.  
  235.      hDC = GetDC(NULL);
  236.      if (!hDC)
  237.           return NULL;
  238.  
  239.      nColors = PalEntriesOnDevice(hDC);
  240.      ReleaseDC(NULL, hDC);
  241.  
  242.      // Allocate room for the palette and lock it.
  243.  
  244.      hLogPal = GlobalAlloc(GHND, sizeof(LOGPALETTE) +
  245.                                   nColors * sizeof(PALETTEENTRY));
  246.  
  247.      if (!hLogPal)
  248.           return NULL;
  249.  
  250.      lpLogPal = (LPLOGPALETTE)GlobalLock(hLogPal);
  251.  
  252.      lpLogPal->palVersion    = 0x300;
  253.      lpLogPal->palNumEntries = (WORD) nColors;
  254.  
  255.      for (i = 0;  i < nColors;  i++)
  256.      {
  257.           lpLogPal->palPalEntry[i].peBlue = (BYTE) 0;
  258.           *((LPWORD)(&lpLogPal->palPalEntry[i].peRed)) = (BYTE) i;
  259.           lpLogPal->palPalEntry[i].peFlags = PC_EXPLICIT;
  260.     }
  261.  
  262.     // Go ahead and create the palette.  Once it's created,
  263.      //  we no longer need the LOGPALETTE, so free it.
  264.  
  265.     hPal = CreatePalette(lpLogPal);
  266.  
  267.     GlobalUnlock(hLogPal);
  268.     GlobalFree(hLogPal);
  269.  
  270.     return hPal;
  271. }
  272.  
  273.  
  274. //
  275. //  FUNCTION: ColorsInPalette(HPALETTE)
  276. //
  277. //  PURPOSE:  Given a handle to a palette, returns the # of colors
  278. //            in that palette.
  279. //
  280. //  PARAMETERS:
  281. //    hPal      - Handle to palette we want info on.
  282. //
  283. //  RETURN VALUE:
  284. //    Number of colors in the given palette
  285. //
  286. //  COMMENTS:
  287. //
  288.  
  289. int ColorsInPalette(HPALETTE hPal)
  290. {
  291.     int nColors=0;
  292.  
  293.     if (!hPal)
  294.         return 0;
  295.  
  296.     GetObject(hPal, sizeof(nColors), (LPSTR)&nColors);
  297.  
  298.     return nColors;
  299. }
  300.